﻿using System;
using System.Collections.Generic;
using System.Linq;
using Autodesk.Revit.DB;
using YJKPatternSign.StairsRoomPlanSign.ModelLayer;

namespace YJKPatternSign.StairsRoomPlanSign.ControlLayer
{
	public class DoubleStairsDimensionPackerGeter : IStairsDimensionPackerGeter
	{
		public DoubleStairsDimensionPackerGeter(SignUseStairsPacker inputPacker)
		{
			this.PrepareInformation(inputPacker);
		}

		public bool TryGetADimensionBean(SignUseStairsPacker useStairs, StairsDimensionKindEnum useKind, out List<IDimensionMake> outPutValue)
		{
			outPutValue = null;
			if (useStairs != this.m_useSairsPacker || this.m_useSairsPacker == null)
			{
				return false;
			}
			switch (useKind)
			{
			case StairsDimensionKindEnum.StairsWidth:
				outPutValue = this.m_lstStairWidthDimensionBean.Cast<IDimensionMake>().ToList<IDimensionMake>();
				break;
			case StairsDimensionKindEnum.StairsLength:
				outPutValue = this.m_lstStiarLengthDimensionBean.Cast<IDimensionMake>().ToList<IDimensionMake>();
				break;
			case StairsDimensionKindEnum.LevelDimension:
				outPutValue = (from n in this.m_lstLevelDimensionPacker
				where n != null
				select n).ToList<LevelDimensionPacker>().Cast<IDimensionMake>().ToList<IDimensionMake>();
				break;
			case StairsDimensionKindEnum.EvacuationRadius:
				outPutValue = this.m_lstEvacuationRadiusInformationBean.Cast<IDimensionMake>().ToList<IDimensionMake>();
				break;
			case StairsDimensionKindEnum.PathDimensionBean:
				outPutValue = this.m_lstUsePathDImensionBean.Cast<IDimensionMake>().ToList<IDimensionMake>();
				break;
			}
			return true;
		}

		private void PrepareInformation(SignUseStairsPacker inputPacker)
		{
			this.m_useSairsPacker = inputPacker;
			this.m_thisStairsCondition = inputPacker.ThisStairsCondition;
			this.PrepareRuns();
			if (this.m_bIfGetInformationRight)
			{
				this.PrePareFlatRoof();
			}
			if (this.m_bIfGetInformationRight)
			{
				this.AddWallInformationToStairsRuns();
			}
			if (this.m_bIfGetInformationRight)
			{
				this.MakeDimensionBean();
			}
		}

		private void MakeDimensionBean()
		{
			this.MakeAllEvacutaionRadiusInformationBean();
			this.MakeAllLevelDimension();
			this.MakeAllStairsWidthDimension();
			this.MakeAllStairsRunsDimension();
			this.MakeAllPath();
		}

		private void MakeAllPath()
		{
			if (this.m_useStairsRunPackerTop != null)
			{
				Line stairRunMidLine = this.m_useStairsRunPackerTop.GetStairRunMidLine(true);
				XYZ item = stairRunMidLine.GetEndPoint(1).Add(-stairRunMidLine.Direction.Normalize() * stairRunMidLine.Length * 0.1);
				PathDimensionBean item2 = new PathDimensionBean(new List<XYZ>
				{
					stairRunMidLine.GetEndPoint(0),
					item
				}, new List<int>
				{
					3,
					1
				});
				this.m_lstUsePathDImensionBean.Add(item2);
			}
			if (this.m_useStairsRunPackerMid != null && this.m_useStairsRunPackerDown != null)
			{
				FlatRoofPacker flatRoofPacker = (from k in this.m_lstAllFlatRoof
				orderby k.ThisElevation
				select k).ElementAt(0);
				List<XYZ> list = new List<XYZ>();
				List<Curve> list2 = new List<Curve>();
				Line stairRunMidLine2 = this.m_useStairsRunPackerMid.GetStairRunMidLine(true);
				Line stairRunMidLine3 = this.m_useStairsRunPackerDown.GetStairRunMidLine(true);
				if (this.m_useStairsRunPackerTop != null)
				{
					if (flatRoofPacker.TryGetAPathInShape(stairRunMidLine2.GetEndPoint(1), stairRunMidLine3.GetEndPoint(0), SignManger.ThisStairPlandDataPacker.NowViewZ, out list2))
					{
						List<XYZ> list3 = new List<XYZ>();
						for (int i = 0; i < list2.Count; i++)
						{
							if (i == list2.Count - 1)
							{
								list.Add(list2[i].GetEndPoint(0));
								XYZ item3 = list2[i].GetEndPoint(1).Add(-(list2[i] as Line).Direction.Normalize() * list2[i].Length * 0.1);
								list.Add(item3);
							}
							else
							{
								list.Add(list2[i].GetEndPoint(0));
							}
						}
						list3.AddRange(list);
						PathDimensionBean item4 = new PathDimensionBean(list3, new List<int>
						{
							3,
							2
						});
						this.m_lstUsePathDImensionBean.Add(item4);
						return;
					}
				}
				else if (flatRoofPacker.TryGetAPathInShape(stairRunMidLine2.GetEndPoint(1), stairRunMidLine3.GetEndPoint(0), SignManger.ThisStairPlandDataPacker.NowViewZ, out list2))
				{
					List<XYZ> list4 = new List<XYZ>();
					for (int j = 0; j < list2.Count; j++)
					{
						if (j == list2.Count - 1)
						{
							list.Add(list2[j].GetEndPoint(0));
							XYZ item5 = list2[j].GetEndPoint(1).Add(-(list2[j] as Line).Direction.Normalize() * list2[j].Length * 0.1);
							list.Add(item5);
						}
						else
						{
							list.Add(list2[j].GetEndPoint(0));
						}
					}
					list4.AddRange(list);
					PathDimensionBean item4 = new PathDimensionBean(list4, new List<int>
					{
						3,
						2
					});
					this.m_lstUsePathDImensionBean.Add(item4);
				}
			}
		}

		private void MakeAllEvacutaionRadiusInformationBean()
		{
			if (this.m_StairsWellUnit != null)
			{
				this.m_StairsWellUnit.TryGetEvacuationRadiusInformation(out this.m_lstEvacuationRadiusInformationBean);
			}
		}

		private void MakeAllLevelDimension()
		{
			using (List<FlatRoofPacker>.Enumerator enumerator = this.m_lstAllFlatRoof.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					LevelDimensionPacker item;
					if (enumerator.Current.TryGetALevelDimension(out item))
					{
						this.m_lstLevelDimensionPacker.Add(item);
					}
				}
			}
			if (this.m_thisStairsCondition == StairConditionEnum.Down)
			{
				this.m_lstLevelDimensionPacker = (from n in this.m_lstLevelDimensionPacker
				where n != null
				select n).ToList<LevelDimensionPacker>();
				this.m_lstLevelDimensionPacker = (from k in this.m_lstLevelDimensionPacker
				orderby k.UseElevation
				select k).ToList<LevelDimensionPacker>();
				if (this.m_lstLevelDimensionPacker.Count > 0)
				{
					LevelDimensionPacker item2 = this.m_lstLevelDimensionPacker[0];
					this.m_lstLevelDimensionPacker = new List<LevelDimensionPacker>
					{
						item2
					};
				}
			}
		}

		private void MakeAllStairsWidthDimension()
		{
			if (this.m_StairsWellUnit != null)
			{
				Line inputLine = this.m_useStairsRunPackerMid.GetStairRunEndCurve(0, false) as Line;
				DimensionInformensionBean item;
				if (this.m_StairsWellUnit.TryGetDimensionInformensionByLine(inputLine, out item, false, true, true))
				{
					this.m_lstStairWidthDimensionBean.Add(item);
					return;
				}
			}
			else
			{
				Line inputLine = this.m_useStairsRunPackerTop.GetStairRunEndCurve(0, false) as Line;
				DimensionInformensionBean item;
				if (this.m_useStairsRunPackerTop.TryGetDimensionInformensionByLine(inputLine, out item, false, true, true))
				{
					this.m_lstStairWidthDimensionBean.Add(item);
				}
			}
		}

		private void MakeAllStairsRunsDimension()
		{
			bool flag = true;
			bool flag2 = false;
			for (int i = 0; i < this.m_lstAllStairsRunnPacker.Count - 1; i++)
			{
				flag = (flag && this.m_lstAllStairsRunnPacker[i].GetRunShapeDesText(false).Equals(this.m_lstAllStairsRunnPacker[i + 1].GetRunShapeDesText(false)));
				flag = (flag && this.IfTwoStairsRunsLocationNear(this.m_lstAllStairsRunnPacker[i], this.m_lstAllStairsRunnPacker[i + 1]));
				if (1 == i && this.m_lstAllStairsRunnPacker[i - 1].ThisStairsRun.GetStairs().ActualTreadDepth != this.m_lstAllStairsRunnPacker[i + 1].ThisStairsRun.GetStairs().ActualTreadDepth)
				{
					flag2 = true;
				}
			}
			this.m_lstStiarLengthDimensionBean.AddRange(this.MakeAStairsLengthDimension(null, true));
			if (!flag)
			{
				this.m_lstStiarLengthDimensionBean.AddRange(this.MakeAStairsLengthDimensionByFlate(new List<StairsRunPacker>
				{
					this.m_useStairsRunPackerDown
				}, !flag2));
				if (flag2)
				{
					Line line = this.m_useStairsRunPackerDown.GetStairRunMidLine(false);
					line = Utility.MoveALineAtVerticalDirection(line, StaticResource.MoveDistanceOfCut, false);
					this.MakeACutDimension(line, this.m_useStairsRunPackerDown);
					this.MakeACutDimension(line, this.m_useStairsRunPackerTop);
				}
			}
		}

		private bool IfTwoStairsRunsLocationNear(StairsRunPacker inputRunOne, StairsRunPacker inputRunTwo)
		{
			bool result = false;
			Curve curve = inputRunOne.GetStairRunMidLine(false);
			curve = curve.Clone();
			curve.MakeUnbound();
			XYZ xyzpoint = curve.Project(inputRunOne.GetStairRunMidLine(false).GetEndPoint(0)).XYZPoint;
			Curve stairRunMidLine = inputRunTwo.GetStairRunMidLine(false);
			for (int i = 0; i < 2; i++)
			{
				if (curve.Project(stairRunMidLine.GetEndPoint(i)).XYZPoint.IsAlmostEqualTo(xyzpoint))
				{
					result = true;
				}
			}
			return result;
		}

		private void MakeACutDimension(Line useCutDimensionLine, StairsRunPacker useRunPacker)
		{
			DimensionInformensionBean dimensionInformensionBean = null;
			if (useRunPacker.TryGetDimensionInformensionByLine(useCutDimensionLine, out dimensionInformensionBean, true, false, false))
			{
				dimensionInformensionBean.LstReplacedText = new List<string>
				{
					useRunPacker.GetRunShapeDesText(false)
				};
				this.m_lstStiarLengthDimensionBean.Add(dimensionInformensionBean);
			}
		}

		private List<DimensionInformensionBean> MakeAStairsLengthDimension(StairsRunPacker inputRun = null, bool ifChangeText = false)
		{
			List<DimensionInformensionBean> list = new List<DimensionInformensionBean>();
			DimensionInformensionBean dimensionInformensionBean = null;
			StairsRunPacker stairsRunPacker;
			if (inputRun == null)
			{
				if (this.m_useStairsRunPackerMid != null)
				{
					stairsRunPacker = this.m_useStairsRunPackerMid;
				}
				else
				{
					stairsRunPacker = this.m_useStairsRunPackerTop;
				}
			}
			else
			{
				stairsRunPacker = inputRun;
			}
			Line line = stairsRunPacker.GetStairRunMidLine(false);
			line = Utility.MoveALineAtVerticalDirection(line, StaticResource.MoveDistanceOfStairsLegth, false);
			if (stairsRunPacker.TryGetDimensionInformensionByLine(line, out dimensionInformensionBean, false, false, false))
			{
				if (ifChangeText)
				{
					dimensionInformensionBean.LstReplacedText = new List<string>
					{
						stairsRunPacker.GetRunShapeDesText(false)
					};
				}
				list.Add(dimensionInformensionBean);
			}
			using (List<FlatRoofPacker>.Enumerator enumerator = this.m_lstAllFlatRoof.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					if (enumerator.Current.TryGetDimensionInformensionByLine(line, out dimensionInformensionBean, false, false, false))
					{
						list.Add(dimensionInformensionBean);
					}
				}
			}
			return list;
		}

		private List<DimensionInformensionBean> MakeAStairsLengthDimensionByFlate(List<StairsRunPacker> inputLstStairsRunPacker, bool ifChangeText)
		{
			List<DimensionInformensionBean> list = new List<DimensionInformensionBean>();
			DimensionInformensionBean item = null;
			string item2 = null;
			if (this.m_useStairsRunPackerTop != null)
			{
				item2 = this.m_useStairsRunPackerTop.GetRunShapeDesText(false);
			}
			else if (this.m_useStairsRunPackerDown != null)
			{
				item2 = this.m_useStairsRunPackerDown.GetRunShapeDesText(false);
			}
			Line line = inputLstStairsRunPacker[0].GetStairRunMidLine(false);
			line = Utility.MoveALineAtVerticalDirection(line, StaticResource.MoveDistanceOfStairsLegth, false);
			using (List<FlatRoofPacker>.Enumerator enumerator = this.m_lstAllFlatRoof.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					if (enumerator.Current.TryGetDimensionInformensionByLine(line, out item, false, false, false))
					{
						list.Add(item);
					}
				}
			}
			if (list.Count >= 2)
			{
				list[0].LstDimensionPoints.AddRange(list[1].LstDimensionPoints);
				list = new List<DimensionInformensionBean>
				{
					list[0]
				};
				if (ifChangeText)
				{
					list[0].LstReplacedText = new List<string>
					{
						null,
						item2,
						null
					};
				}
			}
			return list;
		}

		private void AddWallInformationToStairsRuns()
		{
			StairsRunPacker stairsRunPacker = null;
			int inputIndex = 0;
			if (this.m_useStairsRunPackerMid != null)
			{
				stairsRunPacker = this.m_useStairsRunPackerMid;
			}
			else if (this.m_useStairsRunPackerTop != null)
			{
				stairsRunPacker = this.m_useStairsRunPackerTop;
			}
			if (stairsRunPacker == null)
			{
				return;
			}
			Line line = stairsRunPacker.GetStairRunEndCurve(inputIndex, false) as Line;
			XYZ inputPoint = line.Evaluate(0.5, true);
			for (int i = -1; i < 2; i += 2)
			{
				Curve input;
				if (StairsDimensionUtilityMethod.TryFindABoundaryByPointAndDriection(inputPoint, (double)i * line.Direction, this.m_lstWallCurves, out input))
				{
					stairsRunPacker.AddACurveToShape(input);
				}
			}
		}

		private void PrePareFlatRoof()
		{
			this.m_lstAllFlatRoof = new List<FlatRoofPacker>
			{
				null,
				null
			};
			StairsRunPacker inputPackerTwo = null;
			StairPlanDataPacker useStairPlanData = this.m_useSairsPacker.UseStairPlanData;
			foreach (WallElementPacker wallElementPacker in useStairPlanData.LstAllWallElementPacker)
			{
				foreach (Curve item in wallElementPacker.LstOffestCurve)
				{
					this.m_lstWallCurves.Add(item);
				}
			}
			foreach (ColumnPacker columnPacker in useStairPlanData.LstColumnPackers)
			{
				this.m_lstWallCurves.AddRange(columnPacker.LstBoundCurves);
			}
			this.m_lstWallCurves = Utility.ChangeLstCurveZ(this.m_lstWallCurves, SignManger.ThisStairPlandDataPacker.NowViewZ);
			if (this.m_lstAllStairsRunnPacker.Count > 2)
			{
				this.SetAllFlatRoofByRuns();
			}
			else if (this.m_lstAllStairsRunnPacker.Count == 2)
			{
				this.SetAllFlatRoofByRuns(this.m_lstAllStairsRunnPacker[1], this.m_lstAllStairsRunnPacker[0]);
			}
			else if (this.m_lstAllStairsRunnPacker.Count == 1)
			{
				if (this.TryFindASrairsRunPackerByOneInput(this.m_lstAllStairsRunnPacker[0], true, out inputPackerTwo))
				{
					this.SetAllFlatRoofByRuns(this.m_lstAllStairsRunnPacker[0], inputPackerTwo);
				}
				else
				{
					this.m_bIfGetInformationRight = false;
				}
			}
			else
			{
				this.m_bIfGetInformationRight = false;
			}
			if (this.m_bIfGetInformationRight && this.m_useStairsRunPackerMid != null && this.m_useStairsRunPackerDown != null)
			{
				this.m_StairsWellUnit = new StairsWellUnitPacker(this.m_useStairsRunPackerMid.ThisStairsRun.GetStairs(), this.m_useStairsRunPackerMid, this.m_useStairsRunPackerDown);
			}
		}

		private void SetAllFlatRoofByRuns(StairsRunPacker inputPackerOne, StairsRunPacker inputPackerTwo)
		{
			FlatRoofPacker value = null;
			for (int i = 0; i < 2; i++)
			{
				if (this.TryCreatAFlatRootPackerByTwoRun(inputPackerOne, inputPackerTwo, i == 0, out value))
				{
					this.m_lstAllFlatRoof[i] = value;
				}
				else
				{
					this.m_bIfGetInformationRight = false;
				}
			}
		}

		private void SetAllFlatRoofByRuns()
		{
			FlatRoofPacker value = null;
			for (int i = 0; i < 2; i++)
			{
				if (this.TryCreatAFlatRootPackerByTwoRun(this.m_lstAllStairsRunnPacker[i], this.m_lstAllStairsRunnPacker[i + 1], true, out value))
				{
					this.m_lstAllFlatRoof[i] = value;
				}
				else
				{
					this.m_bIfGetInformationRight = false;
				}
			}
		}

		private void PrepareRuns()
		{
			List<StairsRunPacker> list = this.m_useSairsPacker.LstAllStiarsRunPacker;
			list = (from n in list
			where n.ViewKind > ShapeViewKindEnum.None
			select n).ToList<StairsRunPacker>();
			list = (from k in list
			orderby -k.EndElevation
			select k).ToList<StairsRunPacker>();
			if (list.Count >= 1)
			{
				this.m_lstAllStairsRunnPacker.Add(list[0]);
			}
			if (list.Count >= 2)
			{
				this.m_lstAllStairsRunnPacker.Add(list[1]);
			}
			if (list.Count >= 3)
			{
				for (int i = 2; i < list.Count; i++)
				{
					if (list[0].IfShadowInputStairs(list[i]))
					{
						this.m_lstAllStairsRunnPacker.Add(list[i]);
						double num = -this.m_useSairsPacker.UseViewData.CutHeightZ + this.m_lstAllStairsRunnPacker[0].EndElevation;
						num = list[i].EndElevation - num;
						list[i].UpdataViewKindByInput(num, false);
						break;
					}
				}
			}
			switch (this.m_thisStairsCondition)
			{
			case StairConditionEnum.Down:
				this.m_bIfGetInformationRight = (this.m_bIfGetInformationRight && this.m_lstAllStairsRunnPacker.Count == 1);
				if (this.m_lstAllStairsRunnPacker.Count > 0)
				{
					this.m_useStairsRunPackerTop = this.m_lstAllStairsRunnPacker[0];
					return;
				}
				break;
			case StairConditionEnum.Normal:
				this.m_bIfGetInformationRight = (this.m_bIfGetInformationRight && (this.m_lstAllStairsRunnPacker.Count == 2 || this.m_lstAllStairsRunnPacker.Count == 3));
				if (2 == this.m_lstAllStairsRunnPacker.Count)
				{
					this.m_useStairsRunPackerTop = this.m_lstAllStairsRunnPacker[0];
					this.m_useStairsRunPackerMid = this.m_lstAllStairsRunnPacker[1];
				}
				if (3 == this.m_lstAllStairsRunnPacker.Count)
				{
					this.m_useStairsRunPackerTop = this.m_lstAllStairsRunnPacker[0];
					this.m_useStairsRunPackerMid = this.m_lstAllStairsRunnPacker[1];
					this.m_useStairsRunPackerDown = this.m_lstAllStairsRunnPacker[2];
					return;
				}
				break;
			case StairConditionEnum.Top:
				this.m_bIfGetInformationRight = (this.m_bIfGetInformationRight && this.m_lstAllStairsRunnPacker.Count == 2);
				if (this.m_lstAllStairsRunnPacker.Count > 1)
				{
					this.m_useStairsRunPackerMid = this.m_lstAllStairsRunnPacker[0];
					this.m_useStairsRunPackerDown = this.m_lstAllStairsRunnPacker[1];
					return;
				}
				break;
			case StairConditionEnum.Error:
				this.m_bIfGetInformationRight = false;
				break;
			default:
				return;
			}
		}

		private bool TryFindASrairsRunPackerByOneInput(StairsRunPacker input, bool ifAtUpDriection, out StairsRunPacker findedValue)
		{
			findedValue = null;
			List<StairsRunPacker> list = this.m_useSairsPacker.LstAllStiarsRunPacker;
			list = (from k in list
			orderby -k.EndElevation
			select k).ToList<StairsRunPacker>();
			int num = list.FindIndex((StairsRunPacker k) => k == input);
			if (num == list.Count || list[num] != input)
			{
				return false;
			}
			int num2;
			if (ifAtUpDriection)
			{
				num2 = num - 1;
			}
			else
			{
				num2 = num + 1;
			}
			if (num2 >= list.Count)
			{
				return false;
			}
			findedValue = list[num2];
			return true;
		}

		private bool TryFindAFlatRootPackerByTwoRun(StairsRunPacker inputPackerOne, StairsRunPacker inputPackerTwo, out FlatRoofPacker findedValue)
		{
			findedValue = null;
			foreach (FlatRoofPacker flatRoofPacker in this.m_useSairsPacker.LstAllFlatRoofPacker)
			{
				if (flatRoofPacker.LstLinkeRun.Contains(inputPackerOne) && flatRoofPacker.LstLinkeRun.Contains(inputPackerTwo))
				{
					findedValue = flatRoofPacker;
					return true;
				}
			}
			return false;
		}

		private bool TryCreatAFlatRootPackerByTwoRun(StairsRunPacker inputPackerOne, StairsRunPacker inputPackerTwo, bool ifIntersection, out FlatRoofPacker createdValue)
		{
			createdValue = null;
			bool result = true;
			int num = 0;
			int num2 = 1;
			List<Curve> list = new List<Curve>();
			StairsRunPacker stairsRunPacker;
			StairsRunPacker stairsRunPacker2;
			if (inputPackerOne.EndElevation > inputPackerTwo.EndElevation)
			{
				stairsRunPacker = inputPackerOne;
				stairsRunPacker2 = inputPackerTwo;
			}
			else
			{
				stairsRunPacker = inputPackerTwo;
				stairsRunPacker2 = inputPackerOne;
			}
			double inputElevation = stairsRunPacker.StartElevation;
			if (!ifIntersection)
			{
				num = 1;
				num2 = 0;
				inputElevation = stairsRunPacker.EndElevation;
			}
			if (this.m_thisStairsCondition == StairConditionEnum.Down && !ifIntersection)
			{
				inputElevation = stairsRunPacker2.StartElevation;
			}
			Curve stairRunEndCurve = stairsRunPacker.GetStairRunEndCurve(num, false);
			Curve stairRunEndCurve2 = stairsRunPacker2.GetStairRunEndCurve(num2, false);
			list.Add(stairRunEndCurve);
			list.Add(stairRunEndCurve2);
			XYZ xyz = stairsRunPacker.GetStairRunMidLine(false).Direction;
			XYZ xyz2 = stairsRunPacker2.GetStairRunMidLine(false).Direction;
			if (num == 0)
			{
				xyz = -xyz;
			}
			if (num2 == 0)
			{
				xyz2 = -xyz2;
			}
			Curve curve;
			StairsDimensionUtilityMethod.TryFindANearBoundaryByStairsRun(stairsRunPacker, num, this.m_lstWallCurves, out curve);
			Curve curve2;
			StairsDimensionUtilityMethod.TryFindANearBoundaryByStairsRun(stairsRunPacker2, num2, this.m_lstWallCurves, out curve2);
			if (null != curve)
			{
				list.Add(curve);
			}
			if (null != curve2)
			{
				list.Add(curve2);
			}
			createdValue = new FlatRoofPacker(inputElevation, null, list, new List<StairsRunPacker>
			{
				stairsRunPacker,
				stairsRunPacker2
			});
			return result;
		}

		private SignUseStairsPacker m_useSairsPacker;

		private StairConditionEnum m_thisStairsCondition = StairConditionEnum.Error;

		private List<StairsRunPacker> m_lstAllStairsRunnPacker = new List<StairsRunPacker>();

		private List<FlatRoofPacker> m_lstAllFlatRoof = new List<FlatRoofPacker>();

		private StairsWellUnitPacker m_StairsWellUnit;

		private List<Line> m_lstLine = new List<Line>();

		private bool m_bIfGetInformationRight = true;

		private List<EvacuationRadiusInformationBean> m_lstEvacuationRadiusInformationBean = new List<EvacuationRadiusInformationBean>();

		private List<LevelDimensionPacker> m_lstLevelDimensionPacker = new List<LevelDimensionPacker>();

		private List<DimensionInformensionBean> m_lstStairWidthDimensionBean = new List<DimensionInformensionBean>();

		private List<DimensionInformensionBean> m_lstStiarLengthDimensionBean = new List<DimensionInformensionBean>();

		private List<PathDimensionBean> m_lstUsePathDImensionBean = new List<PathDimensionBean>();

		private StairsRunPacker m_useStairsRunPackerDown;

		private StairsRunPacker m_useStairsRunPackerMid;

		private StairsRunPacker m_useStairsRunPackerTop;

		private List<Curve> m_lstWallCurves = new List<Curve>();
	}
}
